// pages/user/settings/settings.js
const app = getApp()

Page({
  data: {
    userInfo: {},
    originalUserInfo: {}, // 保存原始用户信息用于对比
    hasChanged: false, // 是否有修改
    saving: false,
    loading: true,
    
    // 表单验证
    errors: {},
    
    // 学校相关
    schoolList: [],
    schoolIndex: -1,
    
    // 头像上传
    uploading: false,
    
    // 用户统计信息
    userStats: {
      creditScore: 100,
      publishCount: 0,
      applicationCount: 0,
      completedCount: 0
    },
    
    // 表单项配置
    formItems: [
      {
        key: 'nickname',
        label: '昵称',
        type: 'input',
        placeholder: '请输入昵称',
        required: true,
        maxLength: 20
      },
      {
        key: 'realName',
        label: '真实姓名',
        type: 'input',
        placeholder: '请输入真实姓名',
        required: false,
        maxLength: 10
      },
      {
        key: 'studentNumber',
        label: '学号',
        type: 'input',
        placeholder: '请输入学号',
        required: false,
        readonly: false
      },
      {
        key: 'schoolId',
        label: '学校',
        type: 'picker',
        placeholder: '请选择学校',
        required: false
      },
      {
        key: 'major',
        label: '专业',
        type: 'input',
        placeholder: '请输入专业',
        required: false,
        maxLength: 30
      },
      {
        key: 'grade',
        label: '年级',
        type: 'input',
        placeholder: '如：2023级',
        required: false,
        maxLength: 10
      },
      {
        key: 'phone',
        label: '手机号',
        type: 'input',
        inputType: 'number',
        placeholder: '请输入手机号',
        required: false,
        maxLength: 11
      },
      {
        key: 'qq',
        label: 'QQ号',
        type: 'input',
        inputType: 'number',
        placeholder: '请输入QQ号',
        required: false,
        maxLength: 15
      },
      {
        key: 'wechat',
        label: '微信号',
        type: 'input',
        placeholder: '请输入微信号',
        required: false,
        maxLength: 30
      },
      {
        key: 'email',
        label: '邮箱',
        type: 'input',
        inputType: 'email',
        placeholder: '请输入邮箱地址',
        required: false,
        maxLength: 50
      }
    ]
  },

  onLoad() {
    this.loadAllData()
  },

  onShow() {
    // 每次显示页面时刷新用户信息
    this.loadUserInfo()
  },

  // 加载所有数据
  async loadAllData() {
    this.setData({ loading: true })
    
    try {
      // 先加载学校列表，再加载用户信息（用户信息需要学校列表来补全学校名称）
      await this.loadSchoolList()
      await Promise.all([
        this.loadUserInfo(),
        this.loadUserStats()
      ])
    } catch (error) {
      console.error('加载数据失败:', error)
    } finally {
      this.setData({ loading: false })
    }
  },

  // 加载用户信息
  async loadUserInfo() {
    try {
      const result = await app.utils.request({
        url: '/auth/user/info',
        method: 'GET'
      })
      
      if (result.code === 200) {
        const userInfo = result.data
        
        // 如果有学校ID但没有学校名称，从学校列表中查找
        if (userInfo.schoolId && !userInfo.schoolName && this.data.schoolList.length > 0) {
          const school = this.data.schoolList.find(s => s.id === userInfo.schoolId)
          if (school) {
            userInfo.schoolName = school.schoolName
            console.log('从学校列表补全学校名称:', userInfo.schoolName)
          }
        }
        
        console.log('用户信息加载成功:', userInfo)
        
        this.setData({ 
          userInfo,
          originalUserInfo: JSON.parse(JSON.stringify(userInfo)) // 深拷贝
        })
        
        // 设置学校选择器的索引
        this.setSchoolIndex()
        
        // 更新全局用户信息
        app.globalData.userInfo = userInfo
      } else {
        throw new Error(result.message || '获取用户信息失败')
      }
    } catch (error) {
      console.error('加载用户信息失败:', error)
      if (error.message && error.message.includes('Token')) {
        wx.reLaunch({
          url: '/pages/login/login'
        })
      } else {
        app.utils.showError('加载用户信息失败')
      }
    }
  },

  // 加载学校列表
  async loadSchoolList() {
    try {
      const result = await app.utils.request({
        url: '/schools/list',
        method: 'GET',
        data: {
          page: 1,
          size: 1000,
          status: 1 // 只获取启用的学校
        }
      })
      
      if (result.code === 200) {
        // 处理分页数据
        const records = result.data.records || result.data || []
        
        // 统一字段名：确保每个学校对象都有 schoolName 字段
        const schoolList = records.map(school => ({
          ...school,
          schoolName: school.schoolName || school.name
        }))
        
        console.log('学校列表加载成功:', schoolList)
        this.setData({ schoolList })
        this.setSchoolIndex()
      } else {
        console.error('加载学校列表失败:', result.message)
      }
    } catch (error) {
      console.error('加载学校列表失败:', error)
      // 不显示错误提示，因为这不是关键功能
    }
  },

  // 加载用户统计信息
  async loadUserStats() {
    try {
      const result = await app.utils.request({
        url: '/auth/user/stats',
        method: 'GET'
      })
      
      if (result.code === 200) {
        this.setData({ userStats: result.data })
      }
    } catch (error) {
      console.error('加载用户统计失败:', error)
      // 使用默认值
    }
  },

  // 设置学校选择器索引
  setSchoolIndex() {
    const { userInfo, schoolList } = this.data
    if (userInfo.schoolId && schoolList.length > 0) {
      const index = schoolList.findIndex(school => school.id === userInfo.schoolId)
      this.setData({ schoolIndex: index >= 0 ? index : -1 })
    }
  },

  // 输入框变化处理
  onInputChange(e) {
    const { field } = e.currentTarget.dataset
    const value = e.detail.value
    
    this.setData({ 
      [`userInfo.${field}`]: value,
      hasChanged: true,
      [`errors.${field}`]: '' // 清除该字段的错误信息
    })
    
    // 实时验证
    this.validateField(field, value)
  },

  // 学校选择处理
  onSchoolChange(e) {
    const index = e.detail.value
    const school = this.data.schoolList[index]
    
    if (school) {
      console.log('选择学校:', school)
      
      // 更新用户信息
      const userInfo = this.data.userInfo
      userInfo.schoolId = school.id
      userInfo.schoolName = school.schoolName
      
      this.setData({
        schoolIndex: index,
        userInfo: userInfo,
        hasChanged: true,
        'errors.schoolId': ''
      })
      
      console.log('学校信息已更新:', userInfo.schoolName)
    }
  },

  // 更换头像
  onChangeAvatar() {
    wx.showActionSheet({
      itemList: ['从相册选择', '拍照'],
      success: (res) => {
        let sourceType = []
        if (res.tapIndex === 0) {
          sourceType = ['album']
        } else {
          sourceType = ['camera']
        }
        
        wx.chooseMedia({
          count: 1,
          mediaType: ['image'],
          sourceType: sourceType,
          sizeType: ['compressed'],
          maxDuration: 30,
          success: (chooseRes) => {
            const tempFilePath = chooseRes.tempFiles[0].tempFilePath
            // 上传头像
            this.uploadAvatar(tempFilePath)
          },
          fail: (error) => {
            console.error('选择图片失败:', error)
            if (error.errMsg !== 'chooseMedia:fail cancel') {
              app.utils.showError('选择图片失败')
            }
          }
        })
      }
    })
  },

  // 上传头像
  uploadAvatar(filePath) {
    this.setData({ uploading: true })
    wx.showLoading({ title: '上传中...', mask: true })
    
    // 获取文件后缀
    const fileExtension = filePath.split('.').pop()
    const fileName = `avatar_${Date.now()}.${fileExtension}`
    
    // 使用 wx.uploadFile 上传文件
    wx.uploadFile({
      url: `${app.globalData.baseUrl}/upload/avatar`,
      filePath: filePath,
      name: 'file',
      header: {
        'Authorization': `Bearer ${app.globalData.token}`
      },
      formData: {
        type: 'avatar'
      },
      success: (uploadRes) => {
        try {
          const data = JSON.parse(uploadRes.data)
          if (data.code === 200) {
            const avatarUrl = data.data.url || data.data
            
            // 更新用户信息
            this.setData({
              'userInfo.avatarUrl': avatarUrl,
              hasChanged: true
            })
            
            wx.showToast({
              title: '头像更新成功',
              icon: 'success',
              duration: 2000
            })
          } else {
            throw new Error(data.message || '上传失败')
          }
        } catch (error) {
          console.error('解析上传结果失败:', error)
          // 如果后端没有文件上传接口，先暂存本地路径
          this.setData({
            'userInfo.avatarUrl': filePath,
            hasChanged: true
          })
          wx.showToast({
            title: '头像已选择，请保存',
            icon: 'none',
            duration: 2000
          })
        }
      },
      fail: (error) => {
        console.error('上传头像失败:', error)
        // 如果上传接口不存在，暂存本地路径
        if (error.errMsg && error.errMsg.includes('404')) {
          this.setData({
            'userInfo.avatarUrl': filePath,
            hasChanged: true
          })
          wx.showToast({
            title: '头像已选择，请保存',
            icon: 'none',
            duration: 2000
          })
        } else {
          app.utils.showError('头像上传失败，请重试')
        }
      },
      complete: () => {
        this.setData({ uploading: false })
        wx.hideLoading()
      }
    })
  },

  // 字段验证
  validateField(field, value) {
    const item = this.data.formItems.find(item => item.key === field)
    if (!item) return true
    
    let error = ''
    
    // 将值转换为字符串
    const strValue = value ? String(value) : ''
    
    // 必填验证
    if (item.required && (!strValue || strValue.trim() === '')) {
      error = `${item.label}不能为空`
    }
    
    // 长度验证
    if (strValue && item.maxLength && strValue.length > item.maxLength) {
      error = `${item.label}长度不能超过${item.maxLength}个字符`
    }
    
    // 特殊字段验证
    if (strValue && strValue.trim() !== '') {
      switch (field) {
        case 'phone':
          if (!/^1[3-9]\d{9}$/.test(strValue)) {
            error = '请输入正确的手机号'
          }
          break
        case 'email':
          if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(strValue)) {
            error = '请输入正确的邮箱地址'
          }
          break
        case 'qq':
          if (!/^\d{5,11}$/.test(strValue)) {
            error = 'QQ号应为5-11位数字'
          }
          break
        case 'studentNumber':
          if (strValue.length < 6 || strValue.length > 20) {
            error = '学号长度应为6-20位'
          }
          break
      }
    }
    
    this.setData({ [`errors.${field}`]: error })
    return !error
  },

  // 表单验证
  validateForm() {
    const { userInfo, formItems } = this.data
    let hasError = false
    let errors = {}
    
    formItems.forEach(item => {
      const value = userInfo[item.key] || ''
      if (!this.validateField(item.key, value)) {
        hasError = true
      }
    })
    
    return !hasError
  },

  // 保存用户信息
  async onSave() {
    if (this.data.saving) return
    
    // 检查是否有修改
    if (!this.data.hasChanged) {
      wx.showToast({
        title: '没有修改内容',
        icon: 'none'
      })
      return
    }
    
    // 表单验证
    if (!this.validateForm()) {
      wx.showToast({
        title: '请检查输入内容',
        icon: 'none'
      })
      return
    }
    
    this.setData({ saving: true })
    
    try {
      wx.showLoading({ title: '保存中...', mask: true })
      
      const { userInfo } = this.data
      
      // 构建更新参数（JSON格式）
      const data = {
        nickname: userInfo.nickname || null,
        avatarUrl: userInfo.avatarUrl || null,
        schoolId: userInfo.schoolId || null,
        phone: userInfo.phone || null,
        qq: userInfo.qq || null,
        wechat: userInfo.wechat || null,
        email: userInfo.email || null
      }
      
      // 使用简化的更新接口（后端使用 @RequestBody JSON格式）
      const result = await app.utils.request({
        url: '/auth/user/update-simple',
        method: 'POST',
        data: data
      })
      
      if (result.code === 200) {
        // 更新本地数据
        const updatedUserInfo = result.data
        
        // 保留学校名称（后端可能不返回）
        if (updatedUserInfo.schoolId && !updatedUserInfo.schoolName) {
          // 从学校列表中查找学校名称
          const school = this.data.schoolList.find(s => s.id === updatedUserInfo.schoolId)
          if (school) {
            updatedUserInfo.schoolName = school.schoolName
          } else {
            updatedUserInfo.schoolName = userInfo.schoolName
          }
        }
        
        console.log('保存成功，更新后的用户信息:', updatedUserInfo)
        
        this.setData({
          userInfo: updatedUserInfo,
          originalUserInfo: JSON.parse(JSON.stringify(updatedUserInfo)),
          hasChanged: false,
          errors: {}
        })
        
        // 重新设置学校索引
        this.setSchoolIndex()
        
        // 更新全局用户信息
        app.utils.saveUserInfo(updatedUserInfo, app.globalData.token)
        
        wx.showToast({
          title: '保存成功',
          icon: 'success',
          duration: 2000
        })
      } else {
        throw new Error(result.message || '保存失败')
      }
    } catch (error) {
      console.error('保存失败:', error)
      app.utils.showError(error.message || '保存失败，请重试')
    } finally {
      this.setData({ saving: false })
      wx.hideLoading()
    }
  },

  // 重置表单
  onReset() {
    wx.showModal({
      title: '确认重置',
      content: '确定要重置所有修改吗？',
      success: (res) => {
        if (res.confirm) {
          this.setData({
            userInfo: JSON.parse(JSON.stringify(this.data.originalUserInfo)),
            hasChanged: false,
            errors: {}
          })
          this.setSchoolIndex()
          
          wx.showToast({
            title: '已重置',
            icon: 'success'
          })
        }
      }
    })
  },

  // 下拉刷新
  async onPullDownRefresh() {
    console.log('下拉刷新')
    try {
      await this.loadAllData()
      wx.showToast({
        title: '刷新成功',
        icon: 'success',
        duration: 1500
      })
    } catch (error) {
      console.error('刷新失败:', error)
    } finally {
      wx.stopPullDownRefresh()
    }
  },

  // 返回上一页时的确认
  onUnload() {
    if (this.data.hasChanged) {
      // 注意：onUnload 中无法阻止页面关闭
      // 这里只是做日志记录
      console.log('页面关闭，有未保存的修改')
    }
  },
  
  // 页面隐藏时提示
  onHide() {
    if (this.data.hasChanged) {
      console.log('页面隐藏，有未保存的修改')
    }
  }
})